{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "472388a2",
   "metadata": {},
   "source": [
    "## 实验二   神经网络\n",
    "### 第2题   使用TensorFlow建立一个3层神经网络（如，13×50×1），对wine数据集（wine_data-2.csv）进行分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f47e2b57",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-04-13 22:11:26.980678: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-04-13 22:11:28.786168: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/ist/miniconda3/envs/pytorch/lib/python3.9/site-packages/nvidia/cudnn:/usr/local/cuda-11.7/lib64\n",
      "2023-04-13 22:11:28.786290: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/ist/miniconda3/envs/pytorch/lib/python3.9/site-packages/nvidia/cudnn:/usr/local/cuda-11.7/lib64\n",
      "2023-04-13 22:11:28.786297: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
     ]
    }
   ],
   "source": [
    "#  2023.3.20\n",
    "import tensorflow as tf\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e185420a-b329-4ee8-a045-7ff172167349",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-04-13 22:11:30.757418: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2023-04-13 22:11:30.857435: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /home/ist/miniconda3/envs/pytorch/lib/python3.9/site-packages/nvidia/cudnn:/usr/local/cuda-11.7/lib64\n",
      "2023-04-13 22:11:30.857459: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1934] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2023-04-13 22:11:30.860036: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# 加载数据\n",
    "array1 = []\n",
    "array2 = []\n",
    "train = []\n",
    "train_labels = []\n",
    "test = []\n",
    "test_labels = []\n",
    "\n",
    "with open('wine_data-2.csv', mode='r') as file:\n",
    "    # reading the CSV file\n",
    "    csvFile = csv.reader(file, delimiter=',')\n",
    "    header=next(csvFile)  # 忽略第1行\n",
    "    \n",
    "    # displaying the contents of the CSV file\n",
    "    length = 1   \n",
    "    for lines in csvFile: \n",
    "        subarray = []\n",
    "        if length < 60:    #1到59为标签为0的数据\n",
    "            for i in range(14):\n",
    "                subarray.append(float(lines[i]))\n",
    "            array1.append(subarray) #拿到全部标签为0的数据\n",
    "            \n",
    "        if length > 59 and length < 131: #60到130为标签为1的数据\n",
    "            for i in range(14):\n",
    "                subarray.append(float(lines[i]))\n",
    "            array2.append(subarray)#拿到全部标签为1的数据\n",
    "        length += 1\n",
    "\n",
    "    np.random.shuffle(array1) #乱序\n",
    "    np.random.shuffle(array2)\n",
    " \n",
    "    data1, data2 = tf.split(array1, [47, 12], 0) # 从标签0的数据中取80%做训练数据，约20%做测试数据\n",
    "    data3, data4 = tf.split(array2, [56, 15], 0) # 从标签1的数据中取80%做训练数据，约20%做测试数据\n",
    "    \n",
    "    train1, train_labels1 = tf.split(data1, [13, 1], 1) #分出标签\n",
    "    train2, train_labels2 = tf.split(data3, [13, 1], 1) #分出标签\n",
    "    \n",
    "    test1, test_labels1 = tf.split(data2, [13, 1], 1) #分出标签\n",
    "    test2, test_labels2 = tf.split(data4, [13, 1], 1) #分出标签\n",
    "    \n",
    "    train = tf.concat([train1, train2], 0)   #把两类训练数据合并\n",
    "    \n",
    "    train_labels = tf.concat([train_labels1, train_labels2], 0) #把训练集的标签合并\n",
    "    test = tf.concat([test1, test2], 0) #把两类测试数据合并\n",
    "    test_labels = tf.concat([test_labels1, test_labels2], 0) #把测试集的标签合并\n",
    "    \n",
    "    #train_labels = tf.squeeze(train_labels, axis=1)  #消去标签集的第二维度(103, 1)->(103,0)\n",
    "    #test_labels = tf.squeeze(test_labels, axis=1)\n",
    "    \n",
    "\n",
    "def train_preprocess(x_train, y_train):\n",
    "    x_train = tf.cast(x=x_train, dtype=tf.float32) / 100.0  #对数据的值进行缩放，加速拟合\n",
    "    y_train = tf.cast(x=y_train, dtype=tf.int32)\n",
    "    return x_train, y_train\n",
    "\n",
    "\n",
    "def test_preprocess(x_test, y_test):\n",
    "    x_test = tf.cast(x=x_test, dtype=tf.float32) / 100.0 #对数据的值进行缩放，加速拟合\n",
    "    y_test = tf.cast(x=y_test, dtype=tf.int32)\n",
    "    return x_test, y_test\n",
    "\n",
    "\n",
    "train_db = tf.data.Dataset.from_tensor_slices(tensors=(train, train_labels)) #封装训练\n",
    "train_db = train_db.map(map_func=train_preprocess).shuffle(buffer_size=103).batch(batch_size=13)\n",
    "\n",
    "test_db = tf.data.Dataset.from_tensor_slices(tensors=(test, test_labels))\n",
    "test_db = test_db.map(map_func=test_preprocess).shuffle(buffer_size=27).batch(batch_size=27)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2b928e4e-f04f-4b69-a8e2-9843985c9bb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_10\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_20 (Dense)            (None, 30)                420       \n",
      "                                                                 \n",
      " dense_21 (Dense)            (None, 1)                 31        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 451\n",
      "Trainable params: 451\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# 建立神经网络模型（13×50×1）\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Dense(units=30, activation=tf.nn.relu, use_bias=True, kernel_initializer='glorot_uniform',\n",
    "                          bias_initializer='zeros'),\n",
    "    tf.keras.layers.Dense(units=1, activation=tf.nn.sigmoid, use_bias=True, kernel_initializer='glorot_uniform',\n",
    "                          bias_initializer='zeros')\n",
    "])\n",
    "model.build(input_shape=[None, 13])\n",
    "model.summary()\n",
    "\n",
    "#优化器\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.01, beta_1=0.9, beta_2=0.99, epsilon=1e-08)\n",
    "# learning_rate：float> = 0.学习率；\n",
    "# beta_1：float，0 <beta <1。一般接近1。一阶矩估计的指数衰减率；\n",
    "# beta_2：float，0 <beta <1。一般接近1。二阶矩估计的指数衰减率；\n",
    "# epsilon：float> = 0,模糊因子。如果None，默认为K.epsilon()。该参数是非常小的数，其为了防止在实现中除以零。\n",
    "# decay：float> = 0,每次更新时学习率下降"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "888154a4-8b6e-4c18-8836-5503655f8d40",
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = []\n",
    "ep = []\n",
    "mse = []\n",
    "x = []\n",
    "#训练神经网络\n",
    "for epoch in range(200):\n",
    "    for step, (x_train, y_train) in enumerate(train_db):\n",
    "        with tf.GradientTape() as tape:\n",
    "            logits = model(x_train)\n",
    "            loss = tf.keras.losses.mean_squared_error(y_train, logits)  # 使用均方误差作为损失函数\n",
    "            \n",
    "            tape.watch(model.trainable_variables)\n",
    "        gradient = tape.gradient(target=loss, sources=model.trainable_variables)#梯度下降\n",
    "        optimizer.apply_gradients(zip(gradient, model.trainable_variables))\n",
    "    \n",
    "    total_num = 0\n",
    "    \n",
    "    #测试神经网络\n",
    "    for step, (x_test, y_test) in enumerate(test_db):\n",
    "        logits = model(x_test)\n",
    "        logits = tf.squeeze(logits, 1)#消去第二个维度(27, 1)->(27,0)\n",
    "        y_test = tf.squeeze(y_test, 1)#消去第二个维度(27, 1)->(27,0)\n",
    "        \n",
    "        for i in range(logits.shape[0]):\n",
    "            part1 = logits[:i]\n",
    "            part2 = logits[i + 1:]\n",
    "            val = []\n",
    "            if logits[i] > 0.5: # 对模型输出结果大于0.5的认为是标签为是1的数据\n",
    "                val = tf.constant([1], tf.float32)\n",
    "            else:\n",
    "                val = tf.constant([0], tf.float32)  # 对模型输出结果小于等于0.5的认为是标签为是0的数据\n",
    "            logits = tf.concat([part1, val, part2], axis=0)\n",
    "        \n",
    "        prediction = tf.cast(x=logits, dtype=tf.int32) # 把预测结果转为tf.int32类型\n",
    "        correct = tf.equal(x=prediction, y=y_test)  # 获得一个一维向量，其中值为1表示预测正确\n",
    "        correct = tf.cast(x=correct, dtype=tf.int32)\n",
    "        \n",
    "        correct = tf.reduce_sum(input_tensor=correct)  # 获得每个epoch训练完后预测正确的数据的个数\n",
    "        total_num = x_test.shape[0]\n",
    "    mse.append(tf.reduce_mean(loss))    \n",
    "    accuracy = correct / total_num\n",
    "    acc.append(accuracy)#收集每个epoch在测试集上的准确度\n",
    "    ep.append(epoch)#收集对应的epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3b1b9dcb-09ab-462e-9b6a-772ac6cbe3b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "混淆矩阵：\n",
      "[[5 7]\n",
      " [8 7]]\n",
      "准确率：88.89%\n"
     ]
    }
   ],
   "source": [
    "# 绘制 测试精度VS训练轮次 的曲线\n",
    "plt.title('Accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.plot(ep, acc)\n",
    "plt.show()\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('mse')\n",
    "plt.plot(ep, mse)\n",
    "plt.show()\n",
    "# 导入混淆矩阵的函数\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# 获取测试集的真实标签和预测标签\n",
    "y_true = test_labels.numpy().flatten()\n",
    "y_pred = prediction.numpy()\n",
    "\n",
    "# 计算并打印混淆矩阵\n",
    "cm = confusion_matrix(y_true, y_pred)\n",
    "print(\"混淆矩阵：\")\n",
    "print(cm)\n",
    "\n",
    "# 计算并打印准确率\n",
    "print(\"准确率：{:.2f}%\".format(acc[-1]* 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d29a4f7-9c14-4d6b-9a73-e0aa74379975",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow]",
   "language": "python",
   "name": "conda-env-tensorflow-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
